#include<string>
#include<vector>
using std::string;
using std::vector;

enum s_Har {Byi='b',Rui='r',Dui='d'};

template<s_Har t>
struct sHar_inDer{
//	const s_Har sp_tty;
	int gGong,fFag,ndOng; 
	s_Har get_sHar(){
		return t;
	}
};
sHar_inDer<Byi> b_Har = {0,0,0};
sHar_inDer<Rui> r_Har = {0,0,0};
sHar_inDer<Dui> d_Har = {0,0,0};

template<int i_1,int i_2,int i_3>
class z_Yryer {
	protected:
		int gong, fan, n_dong;
	public:
		z_Yryer():gong(i_1),fan(i_2),n_dong(i_3){}
		
		int get_g(){
			return gong;
		}
		int get_f(){
			return fan;
		}
		int get_nd(){
			return n_dong;
		}
}; 

template<>
class z_Yryer<3, 2, 1> {
protected:
    // 特化版本可以有不同的成员变量（根据需求调整）
    int gong, fan, n_dong;
    string extra_value; // 特化版本新增的成员（示例）
public:
    // 特化版本的构造函数（可以自定义逻辑）
    z_Yryer() : gong(5), fan(10), n_dong(15), extra_value("骑士") {}
    
    // 可以重写成员函数（也可以保持与通用版本一致）
    int get_g() { 
        return gong; // 特化逻辑：返回2倍的gong
    }
    
    int get_f() { 
        return fan; // 保持与通用版本一致
    }
    
    int get_nd() { 
        return n_dong; // 使用特化版本新增的成员
    }
    
    // 特化版本可以新增函数
    string get_extra() {
        return extra_value;
    }
};
typedef z_Yryer<3, 2, 1> s_QIshi_obj;


template<>
class z_Yryer<3, 1, 2> {
protected:
    // 特化版本可以有不同的成员变量（根据需求调整）
    int gong, fan, n_dong;
    string extra_value; // 特化版本新增的成员（示例）
public:
    // 特化版本的构造函数（可以自定义逻辑）
    z_Yryer() : gong(5), fan(10), n_dong(15), extra_value("战士") {}
    
    // 可以重写成员函数（也可以保持与通用版本一致）
    int get_g() { 
        return gong; // 特化逻辑：返回2倍的gong
    }
    
    int get_f() { 
        return fan; // 保持与通用版本一致
    }
    
    int get_nd() { 
        return n_dong; // 使用特化版本新增的成员
    }
    
    // 特化版本可以新增函数
    string get_extra() {
        return extra_value;
    }
};
class z_Yryer<3, 1, 2> s_ZHangShi_obj;


template<>
class z_Yryer<2, 3, 1> {
protected:
    // 特化版本可以有不同的成员变量（根据需求调整）
    int gong, fan, n_dong;
    string extra_value; // 特化版本新增的成员（示例）
public:
    // 特化版本的构造函数（可以自定义逻辑）
    z_Yryer() : gong(5), fan(10), n_dong(15), extra_value("盾卫") {}
    
    // 可以重写成员函数（也可以保持与通用版本一致）
    int get_g() { 
        return gong; // 特化逻辑：返回2倍的gong
    }
    
    int get_f() { 
        return fan; // 保持与通用版本一致
    }
    
    int get_nd() { 
        return n_dong; // 使用特化版本新增的成员
    }
    
    // 特化版本可以新增函数
    string get_extra() {
        return extra_value;
    }
};
class z_Yryer<2, 3, 1> s_dUnWei_obj;



template<typename T> 
class zHero_dby {
	protected:
		//z_Yryer<T>
		T s_zYeyr;
		s_Har sh;
	public:
		zHero_dby(const zHero_dby<T>& zhdby){
			sh = zhdby.get_sHar();
		} 
	    zHero_dby(T t,s_Har s):s_zYeyr(t),sh(s){}
		
		vector<int> get_HeroNliyr(){
			int i[3]={s_zYeyr.get_g(),s_zYeyr.get_f(),s_zYeyr.get_nd()};
			switch(sh){
				case Byi:
					i[0] += b_Har.gGong,i[1] += b_Har.fFag,i[2] += b_Har.ndOng;
					break;
				case Rui:
					i[0] += r_Har.gGong,i[1] += r_Har.fFag,i[2] += r_Har.ndOng;
					break;
				case Dui:
					i[0] += d_Har.gGong,i[1] += d_Har.fFag,i[2] += d_Har.ndOng;
					break;
			}
			return vector<int>(i,i+3);
		}
		s_Har get_sHar(){
			return sh;
		} 
};


enum x_sHurruir {i_r='r',iFk='f',iHx='h',eMh='m',eHk='h',e_y='y'};
enum p_nKarZirter {_A__=1,_2__=2,_3__=3,_4__=4,_5__=5,_6__=6,_7__=7,_8__=8,_9__=9,_10__=10,
    _J__=11,_Q__=12,_K__=13,_r__=14,_y__=15};
//r = 小王，y = 大王 

class k_nKar {
	protected:
		x_sHurruir s_Px;
		p_nKarZirter n_kz;
	public:
		// 修正1：拷贝构造函数参数改为const引用
		k_nKar(const k_nKar& i){
			s_Px = i.get_Px();
			n_kz = i.get_kz();
		}
		k_nKar(x_sHurruir x, p_nKarZirter p):s_Px(x),n_kz(p){}
		
		// 修正3：getter函数声明为const（确保const对象可调用）
		x_sHurruir get_Px() const {
			return s_Px;
		}
		p_nKarZirter get_kz() const {
			return n_kz;
		} 
};

template<int t_Pkz>
class n_Soupai_kz{
	protected:
		int k_nSum;
		// 修正2：用vector替代数组，避免需要默认构造函数
		vector<k_nKar> sp_z;
	public:
		// 构造函数调整为初始化vector
		n_Soupai_kz(k_nKar it[t_Pkz]):k_nSum(t_Pkz){
		    for(int i=0;i<t_Pkz;i++){
		    	sp_z.push_back(it[i]); // 调用拷贝构造函数，无需默认构造
			}	
		}
		vector<k_nKar> get_Soupai_kz(){
			return sp_z; 
		} 
		
		int get_nSum(){
			return k_nSum;
		}
		// 游戏功能设计（略）
		/* 手札功能区 */
};

//以下技能区； 

template<typename t_Tyir, int n>
struct get_nPoker_impl;

template<typename t_Tyir>
class zhi_Ye__{
	protected:
		zHero_dby<t_Tyir> _zhiYeir__;
	public:
		zhi_Ye__(zHero_dby<t_Tyir> t):_zhiYeir__(t){}
	    zhi_Ye__(s_Har sh):_zhiYeir__(t_Tyir(),sh){} 
	    
	template<int n>
    int get_nPoker(n_Soupai_kz<n> zvr) {
    	n_Soupai_kz<n> z_Vr(zvr); 
        return get_nPoker_impl<t_Tyir, n>::calc(*this,z_Vr);
    }
};
